

#include "ServerThread.h"

using namespace std;

//Metodos de la clase.
//Constructor que envía por parámetro a la clase heredada.
ServerThread::ServerThread(bool atributo) : Thread(atributo){
	this->mutexHandlers = new ThreadMutex();
	this->conex = NULL;
}

//Destructor
ServerThread::~ServerThread(){
	this->mutexHandlers->Eliminar();
	free(this);
}

//Manejador de señales, para que el padre le avise que terminó.
void ServerThread::signalHandler(int signal){
	/*
	//Procedo a finalizar el thread.
	cout << "------------------------------------------------------------------------" << endl;
	cout << "[INFO] - Servidor interrumpido en proceso de apagado                    " << endl;
	cout << "[INFO] - Por favor espere hasta que se desconecten todos los clientes   " << endl;

	//Luego uno a uno los hilos clientes.
	mutexHandlersStatic->P();
	for (std::list<ClientHandlerThread *>::iterator it = listaHandlersStatic->begin(); it != listaHandlersStatic->end(); it++){
		ClientHandlerThread *aux = *it;
		pthread_kill(aux->get_id(),SIGUSR2);
		//Espero su finalización.
		aux->join();
	}
	mutexHandlersStatic->V();

	cout << "[INFO] - Clientes desconectados, cerrando conexión y archivos de log.   " << endl;

	//Cierro la this->conexión y el this->log.
	conexStatic	->closeSocket();
	logStatic	->closeLog();

	cout << "[EXIT] - FIN                                                            " << endl;
	cout << "------------------------------------------------------------------------" << endl;

	//Termino el thread
	pthread_exit(NULL);
	*/
}


//Contiene la ejecución del Thread
void ServerThread::run(){
	/*
	string linea;

	//Me attacho a la señal que envia el server para finalizar.
	signal(SIGUSR1,ServerThread::signalHandler);

	//Inicio el servidor, conexion, socket, logs, etc.
	this->iniciarElServidor();

	//Tomo los parametros staticos para el manejador de señales
	mutexHandlersStatic = this->mutexHandlers;
	conexStatic 		= this->conex;
	listaHandlersStatic = &(this->listaHandlers);

	//Comienzo a aceptar this->conexiones, mientras que este funcionando el servidor y el input de comandos.
	while(true){
		//Conecto
		this->conex->acceptClient();
		//Informo por consola la this->conexion
		cout << "[INFO] - Se conecto un cliente IP:"<< this->conex->getIPCliente().c_str() << endl;
		//Thread manejador
		ClientHandlerThread *handler = new ClientHandlerThread(ATTACH);
		//Mando los datos que necesita el thread
		handler->setClientSocket(this->conex);
		handler->setMutexListaHandlers(this->mutexHandlers);
		handler->setListaHandlers(&(this->listaHandlers));
		//run
		handler->start();
		//Me guardo la referencia al handler
		this->mutexHandlers->P();
		this->listaHandlers.push_back(handler);
		this->mutexHandlers->V();
	}

	//Termino el servidor y cierro las conexiones, log, etc
	this->finalizarElServidor();

	//Termino el thread
	pthread_exit(NULL);
	*/
}

//Inicia el servidor, log y conexion.
void ServerThread::iniciarElServidor(){
	/*
	server *dato;

	//Tomo el dato server donde cargar el socket.
	dato = ((server*) (this->get_dato()));

	//Borro la pantalla al iniciar el Servidor.
	int i = system("clear");
	i = i+1;

	//Titulo
	cout << "TP3 EJ4 - Sistemas Operativos." << endl;
	cout << "------------------------------------------------------------------------" << endl;
	//Inicio el Socket
	cout << "[INFO] - Iniciando Servidor..." << endl;
	cout << "[INFO] - Iniciando Socket..." << endl;

	//Conecto
	this->conex = new Socket(dato->puerto);
	this->conex->bindSocket();

	//Confirmacion de socket ok
	cout << "[INFO] - Socket - OK" << endl;
	cout << "[INFO] - Servidor - OK - IP:" << this->conex->getIPServer().c_str() << " - Puerto: " << dato->puerto << endl;

	//Libero el mutex del server para que pueda atender a los hijos.
	dato->mutex_server->V();
	*/
}

void ServerThread::finalizarElServidor(){
	/*
	//Procedo a finalizar el thread.
	cout << "------------------------------------------------------------------------" << endl;
	cout << "[INFO] - Servidor en proceso de apagado                                 " << endl;
	cout << "[INFO] - Por favor espere hasta que se desconecten todos los clientes	 " << endl;

	//Luego uno a uno los hilos clientes.
	this->mutexHandlers->P();
	for (std::list<ClientHandlerThread *>::iterator it = this->listaHandlers.begin(); it != this->listaHandlers.end(); it++){
		ClientHandlerThread *aux = *it;
		pthread_kill(aux->get_id(),SIGUSR2);
		//Espero su finalización.
		aux->join();
	}
	this->mutexHandlers->V();

	cout << "[INFO] - Clientes desconectados, cerrando conexión y archivos de log.   " << endl;
	cout << "------------------------------------------------------------------------" << endl;

	//Cierro la conexión 
	this->conex->closeSocket();

	cout << "[EXIT] - FIN                                                            " << endl;
	*/
}
